# --------------------------------------------------------
# ohd-sjtu_evaluation
# Licensed under The MIT License [see LICENSE for details]
# Written by Jian Ding, based on code from Bharath Hariharan
# --------------------------------------------------------

"""
    To use the code, users should to config detpath, annopath and imagesetfile
    detpath is the path for 15 result files, for the format, you can refer to "http://captain.whu.edu.cn/DOTAweb/tasks.html"
    search for PATH_TO_BE_CONFIGURED to config the paths
    Note, the evaluation is on the large scale images
"""

import numpy as np
import polyiou
import sys

sys.path.append('../')

from libs.configs import cfgs


def parse_gt(filename):
    """

    :param filename: ground truth file to parse
    :return: all instances in a picture
    """
    objects = []
    with open(filename, 'r') as f:
        while True:
            line = f.readline()
            if line:
                splitlines = line.strip().split(' ')
                object_struct = {}
                if len(splitlines) < 9:
                    continue
                object_struct['name'] = splitlines[10]

                if len(splitlines) == 11:
                    object_struct['difficult'] = 0
                elif len(splitlines) == 12:
                    object_struct['difficult'] = int(splitlines[11])
                object_struct['bbox'] = [float(splitlines[0]),
                                         float(splitlines[1]),
                                         float(splitlines[2]),
                                         float(splitlines[3]),
                                         float(splitlines[4]),
                                         float(splitlines[5]),
                                         float(splitlines[6]),
                                         float(splitlines[7])]

                x_ctr = (float(splitlines[0]) + float(splitlines[2]) + float(splitlines[4]) + float(splitlines[6])) / 4.
                y_ctr = (float(splitlines[1]) + float(splitlines[3]) + float(splitlines[5]) + float(splitlines[7])) / 4.

                detla_x = float(splitlines[8]) - x_ctr
                detla_y = float(splitlines[9]) - y_ctr

                if (detla_x >= 0) and (detla_y >= 0):
                    object_struct['head'] = 0
                elif (detla_x >= 0) and (detla_y <= 0):
                    object_struct['head'] = 1
                elif (detla_x <= 0) and (detla_y <= 0):
                    object_struct['head'] = 2
                else:
                    object_struct['head'] = 3

                objects.append(object_struct)
            else:
                break
    return objects


def voc_ap(rec, prec, use_07_metric=False):
    """ ap = voc_ap(rec, prec, [use_07_metric])
    Compute VOC AP given precision and recall.
    If use_07_metric is true, uses the
    VOC 07 11 point method (default:False).
    """
    if use_07_metric:
        # 11 point metric
        ap = 0.
        for t in np.arange(0., 1.1, 0.1):
            if np.sum(rec >= t) == 0:
                p = 0
            else:
                p = np.max(prec[rec >= t])
            ap += p / 11.
    else:
        # correct AP calculation
        # first append sentinel values at the end
        mrec = np.concatenate(([0.], rec, [1.]))
        mpre = np.concatenate(([0.], prec, [0.]))

        # compute the precision envelope
        for i in range(mpre.size - 1, 0, -1):
            mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])

        # to calculate area under PR curve, look for points
        # where X axis (recall) changes value
        i = np.where(mrec[1:] != mrec[:-1])[0]

        # and sum (\Delta recall) * prec
        ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
    return ap


def voc_eval(detpath,
             annopath,
             imagesetfile,
             classname,
             # cachedir,
             ovthresh=0.5,
             use_07_metric=False):
    """rec, prec, ap = voc_eval(detpath,
                                annopath,
                                imagesetfile,
                                classname,
                                [ovthresh],
                                [use_07_metric])
    Top level function that does the PASCAL VOC evaluation.
    detpath: Path to detections
        detpath.format(classname) should produce the detection results file.
    annopath: Path to annotations
        annopath.format(imagename) should be the xml annotations file.
    imagesetfile: Text file containing the list of images, one image per line.
    classname: Category name (duh)
    cachedir: Directory for caching the annotations
    [ovthresh]: Overlap threshold (default = 0.5)
    [use_07_metric]: Whether to use VOC07's 11 point AP computation
        (default False)
    """
    # assumes detections are in detpath.format(classname)
    # assumes annotations are in annopath.format(imagename)
    # assumes imagesetfile is a text file with each line an image name
    # cachedir caches the annotations in a pickle file

    # first load gt
    with open(imagesetfile, 'r') as f:
        lines = f.readlines()
    imagenames = [x.strip() for x in lines]

    recs = {}
    for i, imagename in enumerate(imagenames):

        recs[imagename] = parse_gt(annopath.format(imagename))

    # extract gt objects for this class
    class_recs = {}
    npos = 0
    for imagename in imagenames:
        R = [obj for obj in recs[imagename] if obj['name'] == classname]
        bbox = np.array([x['bbox'] for x in R])
        difficult = np.array([x['difficult'] for x in R]).astype(np.bool)
        head = np.array([x['head'] for x in R]).astype(np.int)
        det = [False] * len(R)
        npos = npos + sum(~difficult)
        class_recs[imagename] = {'bbox': bbox,
                                 'difficult': difficult,
                                 'head': head,
                                 'det': det}

    # read dets from Task1* files
    detfile = detpath.format(classname)
    with open(detfile, 'r') as f:
        lines = f.readlines()

    splitlines = [x.strip().split(' ') for x in lines]
    image_ids = [x[0] for x in splitlines]
    confidence = np.array([float(x[1]) for x in splitlines])
    head_cls = np.array([int(x[-1]) for x in splitlines])

    # print('check confidence: ', confidence)

    BB = np.array([[float(z) for z in x[2:-1]] for x in splitlines])

    # sort by confidence
    sorted_ind = np.argsort(-confidence)
    sorted_scores = np.sort(-confidence)

    # print('check sorted_scores: ', sorted_scores)
    # print('check sorted_ind: ', sorted_ind)

    # note the usage only in numpy not for list
    BB = BB[sorted_ind, :]
    image_ids = [image_ids[x] for x in sorted_ind]
    head_cls = [head_cls[x] for x in sorted_ind]
    # print('check imge_ids: ', image_ids)
    # print('imge_ids len:', len(image_ids))
    # go down dets and mark TPs and FPs
    nd = len(image_ids)
    tp = np.zeros(nd)
    fp = np.zeros(nd)
    tp_head, head_cnt = 0, 0
    for d in range(nd):
        R = class_recs[image_ids[d]]
        bb = BB[d, :].astype(float)
        head = head_cls[d]
        ovmax = -np.inf
        BBGT = R['bbox'].astype(float)
        HEADGT = R['head'].astype(int)

        # compute det bb with each BBGT

        if BBGT.size > 0:
            # compute overlaps
            # intersection

            # 1. calculate the overlaps between hbbs, if the iou between hbbs are 0, the iou between obbs are 0, too.
            # pdb.set_trace()
            BBGT_xmin =  np.min(BBGT[:, 0::2], axis=1)
            BBGT_ymin = np.min(BBGT[:, 1::2], axis=1)
            BBGT_xmax = np.max(BBGT[:, 0::2], axis=1)
            BBGT_ymax = np.max(BBGT[:, 1::2], axis=1)
            bb_xmin = np.min(bb[0::2])
            bb_ymin = np.min(bb[1::2])
            bb_xmax = np.max(bb[0::2])
            bb_ymax = np.max(bb[1::2])

            ixmin = np.maximum(BBGT_xmin, bb_xmin)
            iymin = np.maximum(BBGT_ymin, bb_ymin)
            ixmax = np.minimum(BBGT_xmax, bb_xmax)
            iymax = np.minimum(BBGT_ymax, bb_ymax)
            iw = np.maximum(ixmax - ixmin + 1., 0.)
            ih = np.maximum(iymax - iymin + 1., 0.)
            inters = iw * ih

            # union
            uni = ((bb_xmax - bb_xmin + 1.) * (bb_ymax - bb_ymin + 1.) +
                   (BBGT_xmax - BBGT_xmin + 1.) *
                   (BBGT_ymax - BBGT_ymin + 1.) - inters)

            overlaps = inters / uni

            BBGT_keep_mask = overlaps > 0
            BBGT_keep = BBGT[BBGT_keep_mask, :]
            BBGT_keep_index = np.where(overlaps > 0)[0]
            # pdb.set_trace()
            def calcoverlaps(BBGT_keep, bb):
                overlaps = []
                for index, GT in enumerate(BBGT_keep):

                    overlap = polyiou.iou_poly(polyiou.VectorDouble(BBGT_keep[index]), polyiou.VectorDouble(bb))
                    overlaps.append(overlap)
                return overlaps
            if len(BBGT_keep) > 0:
                overlaps = calcoverlaps(BBGT_keep, bb)

                ovmax = np.max(overlaps)
                jmax = np.argmax(overlaps)
                # pdb.set_trace()
                jmax = BBGT_keep_index[jmax]

        if ovmax > ovthresh:
            if not R['difficult'][jmax]:
                if not R['det'][jmax]:

                    if HEADGT[jmax] == head:
                        tp[d] = 1.
                        R['det'][jmax] = 1.
                        tp_head += 1.
                    else:
                        fp[d] = 1.
                    head_cnt += 1
                else:
                    fp[d] = 1.
        else:
            fp[d] = 1.

    # compute precision recall

    # print('check fp:', fp)
    # print('check tp', tp)

    print('npos num:', npos)
    fp = np.cumsum(fp)
    tp = np.cumsum(tp)

    rec = tp / float(npos)
    # avoid divide by zero in case the first detection matches a difficult
    # ground truth
    prec = tp / np.maximum(tp + fp, np.finfo(np.float64).eps)
    ap = voc_ap(rec, prec, use_07_metric)

    head_acc = tp_head / (head_cnt + 1e-5)

    return rec, prec, ap, head_acc


def main():

    # ##TODO: wrap the code in the main

    detpath = r'../tools/test_ohd_sjtu/%s/ohd_sjtu_res/Task1_{:s}.txt' % cfgs.VERSION
    annopath = r'/data/yangxue/dataset/OHD-SJTU/test/rotation_txt/{:s}.txt' # change the directory to the path of val/labelTxt, if you want to do evaluation on the valset
    imagesetfile = r'/data/yangxue/code/R3Det_Tensorflow/data/io/OHD-SJTU/ohd-sjtu-testset.txt'
    classnames = ['plane', 'ship']

    # annopath = r'/data/yangxue/dataset/OHD-SJTU-ALL/test/rotation_txt/{:s}.txt'  # change the directory to the path of val/labelTxt, if you want to do evaluation on the valset
    # imagesetfile = r'/data/yangxue/code/R3Det_Tensorflow/data/io/OHD-SJTU/ohd-sjtu-all-testset.txt'
    # classnames = ['small-vehicle', 'ship', 'plane', 'large-vehicle', 'helicopter', 'harbor']
    aps, head_accs = [], []
    ovthreshes = [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
    for ovthresh in ovthreshes:
        classaps, class_head_accs = [], []
        map = 0
        head_macc = 0
        for classname in classnames:
            print('classname:', classname)
            rec, prec, ap, head_acc = voc_eval(detpath,
                                               annopath,
                                               imagesetfile,
                                               classname,
                                               ovthresh=ovthresh,
                                               use_07_metric=True)
            map += ap
            head_macc += head_acc
            # print('rec: ', rec, 'prec: ', prec, 'ap: ', ap)
            print('ap:{}, head_acc:{}'.format(ap, head_acc))
            classaps.append(ap)
            class_head_accs.append(head_acc)

            # uncomment to show p-r curve of each category
            # plt.figure(figsize=(8,4))
            # plt.xlabel('recall')
            # plt.ylabel('precision')
            # plt.plot(rec, prec)
            # plt.show()
        map /= len(classnames)
        head_macc /= len(classnames)
        print('map:{}, head_macc:{}'.format(map, head_macc))
        classaps = 100*np.array(classaps)
        class_head_accs = 100*np.array(class_head_accs)
        print('classaps:{}, class_head_accs:{}'.format(classaps, class_head_accs))
        print('************************'*2)
        aps.append(map)
        head_accs.append(head_macc)
    print(aps, sum(aps)/len(aps))
    print(head_accs, sum(head_accs)/len(head_accs))
if __name__ == '__main__':
    main()